package com.kujie.ai.utils;

import java.util.ArrayList;
import java.util.List;

/**
 * 文件工具
 *
 * @author check
 * @date 2025-07-25
 */
public class FileUtils {

    public static List<String> splitString(String content, int chunkSize) {
        List<String> chunks = new ArrayList<>();
        if (content == null || content.isEmpty()) {
            return chunks; // 空内容直接返回空列表
        }

        int length = content.length();
        for (int start = 0; start < length; start += chunkSize) {
            int end = Math.min(start + chunkSize, length); // 避免越界
            chunks.add(content.substring(start, end));
        }
        return chunks;
    }

    /**
     * 检测内容是否可能是二进制数据
     * @param content 内容
     * @return 如果可能是二进制数据返回true
     */
    public static boolean isLikelyBinaryData(String content) {
        if (content == null || content.isEmpty()) {
            return false;
        }

        // 检查是否包含大量不可打印字符
        int nonPrintableCount = 0;
        int totalLength = Math.min(content.length(), 1000); // 只检查前1000个字符

        for (int i = 0; i < totalLength; i++) {
            char c = content.charAt(i);
            if (c < 32 && c != '\n' && c != '\r' && c != '\t') {
                nonPrintableCount++;
            }
        }

        // 如果不可打印字符超过40%，很可能是二进制数据
        return (nonPrintableCount * 100.0 / totalLength) > 40;
    }

    public static String handlePotentialBinaryData(String content) {
        // 如果内容为空或已经是有效的UTF-8字符串，直接返回
        if (content == null || content.isEmpty()) {
            return content;
        }

        // 检查是否已经是有效的UTF-8
        if (isValidUTF8(content) && !isMeaninglessText(content)) {
            return content;
        }

        // 尝试多种解码方式
        String[] encodings = {"GBK", "ISO-8859-1", "UTF-16"};

        for (String encoding : encodings) {
            try {
                byte[] bytes = content.getBytes(encoding);
                String result = new String(bytes, java.nio.charset.StandardCharsets.UTF_8);
                if (isValidUTF8(result) && !isMeaninglessText(result)) {
                    return result;
                }
            } catch (Exception e) {
                // 继续尝试其他编码
            }
        }

        // 尝试将内容作为Base64解码后再转UTF-8
        try {
            byte[] decodedBytes = java.util.Base64.getDecoder().decode(content);
            String result = new String(decodedBytes, java.nio.charset.StandardCharsets.UTF_8);
            if (isValidUTF8(result) && !isMeaninglessText(result)) {
                return result;
            }
        } catch (IllegalArgumentException e) {
            // 不是有效的Base64字符串
        }

        // 如果所有转换都失败，返回过滤后的文本
        return filterNonPrintableChars(content);
    }

    public static boolean isValidUTF8(String string) {
        if (string == null || string.isEmpty()) {
            return true;
        }

        try {
            byte[] bytes = string.getBytes(java.nio.charset.StandardCharsets.UTF_8);
            String decoded = new String(bytes, java.nio.charset.StandardCharsets.UTF_8);
            return decoded.equals(string);
        } catch (Exception e) {
            return false;
        }
    }

    public static boolean isMeaninglessText(String text) {
        if (text == null || text.isEmpty()) {
            return true;
        }

        // 检查是否包含过多的不可打印字符
        int nonPrintableCount = 0;
        int totalLength = text.length();

        // 只检查前1000个字符以提高性能
        int checkLength = Math.min(totalLength, 1000);

        for (int i = 0; i < checkLength; i++) {
            char c = text.charAt(i);
            // 检查是否为控制字符（除了常见的换行符和制表符）
            if (c < 32 && c != '\n' && c != '\r' && c != '\t') {
                nonPrintableCount++;
            }
        }

        // 如果不可打印字符超过30%，则认为是无意义文本
        return (nonPrintableCount * 100.0 / checkLength) > 30;
    }

    public static String filterNonPrintableChars(String input) {
        if (input == null) return null;

        StringBuilder sb = new StringBuilder();
        boolean lastWasSpace = false;

        for (int i = 0; i < input.length(); i++) {
            char c = input.charAt(i);

            // 保留可打印字符和常见的空白字符
            if (c == '\n' || c == '\r') {
                if (!lastWasSpace) {
                    sb.append(' ');
                    lastWasSpace = true;
                }
            } else if (c == '\t') {
                sb.append(c);
                lastWasSpace = false;
            } else if (c >= 32 && c <= 126) {
                sb.append(c);
                lastWasSpace = false;
            } else if (c > 127 && c <= 0xD7FF) {
                sb.append(c);
                lastWasSpace = false;
            } else if (c >= 0xE000 && c <= 0xFFFD) {
                sb.append(c);
                lastWasSpace = false;
            } else if (Character.isWhitespace(c)) {
                if (!lastWasSpace) {
                    sb.append(' ');
                    lastWasSpace = true;
                }
            }
            // 忽略其他所有字符
        }

        return sb.toString().trim();
    }

    // ... 保留现有的方法 ...

    /**
     * 根据文件类型处理内容
     * @param content 原始内容
     * @param fileType 文件类型
     * @return 处理后的内容
     */
    public static String handleContentByFileType(String content, String fileType) {
        if (content == null || content.isEmpty()) {
            return content;
        }

        // 对于PDF、DOC、DOCX等二进制文件类型，在存储时已经转换为文本
        // 这里只需要确保是UTF-8编码的文本
        return handlePotentialBinaryData(content);
    }

    /**
     * 清理和格式化文本内容
     * @param content 原始内容
     * @return 清理后的内容
     */
    public static String cleanTextContent(String content) {
        if (content == null || content.isEmpty()) {
            return content;
        }

        // 移除多余的空白行
        content = content.replaceAll("\n\\s*\n\\s*\n", "\n\n");

        // 移除行首行尾的空白字符
        String[] lines = content.split("\n");
        StringBuilder sb = new StringBuilder();
        for (String line : lines) {
            sb.append(line.trim()).append("\n");
        }

        return sb.toString().trim();
    }
}
